package com.kly.sc.api.application.strategy;

import com.kly.user.dto.UserConversationDto;
import com.kly.user.dto.UserConversationRecordDto;
import com.kly.user.enums.ConversationType;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public class RuleTree {
    private final RuleNode root;

    public RuleTree(Map<Integer, List<UserConversationRecordDto>> userRecordListMap,
                    UserConversationDto userConversation, String toUserCode) {
        this.root = buildTree(userRecordListMap, userConversation, toUserCode);
    }

    private RuleNode noUserConversationTree(int firstSessionNumber, int validSessionNumber, int deepSessionNumber) {
        //如果破冰会话、有效会话数、深度会话数不为0
        if (firstSessionNumber > 0 && validSessionNumber > 0 && deepSessionNumber > 0) {
            return new DynamicValueNode(100);
            //如果破冰会话、有效会话数
        } else if (firstSessionNumber > 0 && validSessionNumber > 0) {
            return new DynamicValueNode(30);
            //如果破冰会话
        } else if (firstSessionNumber > 0) {
            return new DynamicValueNode(5);
        } else {
            return new DynamicValueNode(2);
        }
    }

    private RuleNode existingUserConversationTree(boolean existsFirstSession, boolean existsValidSession, boolean existsDeepSession,
                                                  int firstSessionNumber, int validSessionNumber, int deepSessionNumber) {

        // 如果存在深度会话
        if (existsDeepSession) {
            return new DynamicValueNode(100);
        }

        // 如果存在有效会话，且深度会话数不为0
        if (existsValidSession && deepSessionNumber > 0) {
            return new DynamicValueNode(100);
        }

        // 如果存在有效会话
        if (existsValidSession) {
            return new DynamicValueNode(30);
        }

        // 如果存在破冰会话，且有效会话数、深度会话数不为0
        if (existsFirstSession && validSessionNumber > 0 && deepSessionNumber > 0) {
            return new DynamicValueNode(100);
        }

        // 如果存在破冰会话，且有效会话数不为0
        if (existsFirstSession && validSessionNumber > 0) {
            return new DynamicValueNode(30);
        }

        // 如果存在破冰会话
        if (existsFirstSession) {
            return new DynamicValueNode(5);
        }

        // 如果以上都不符合，以下是处理不存在任何会话的情况
        return noUserConversationTree(firstSessionNumber, validSessionNumber, deepSessionNumber);
    }


    private RuleNode buildTree(Map<Integer, List<UserConversationRecordDto>> userRecordListMap,
                               UserConversationDto userConversation, String toUserCode) {
        int firstSessionNumber = Optional.ofNullable(userRecordListMap.get(ConversationType.FIRST_CONVERSATION.getCode()))
                .map(List::size)
                .orElse(0);//获取破冰会话使用数量
        int validSessionNumber = Optional.ofNullable(userRecordListMap.get(ConversationType.EFFECTIVE_CONVERSATIONS.getCode()))
                .map(List::size)
                .orElse(0);//获取有效会话使用数量
        int deepSessionNumber = Optional.ofNullable(userRecordListMap.get(ConversationType.DEEP_CONVERSATIONS.getCode()))
                .map(List::size)
                .orElse(0);//获取深度会话使用数量

        boolean existsFirstSession = Optional.ofNullable(userRecordListMap.get(ConversationType.FIRST_CONVERSATION.getCode()))
                .orElse(Collections.emptyList())
                .stream()
                .anyMatch(record -> toUserCode.equals(record.getToUserCode()));//是否存在破冰会话

        boolean existsValidSession = Optional.ofNullable(userRecordListMap.get(ConversationType.EFFECTIVE_CONVERSATIONS.getCode()))
                .orElse(Collections.emptyList())
                .stream()
                .anyMatch(record -> toUserCode.equals(record.getToUserCode()));//是否存在有效会话

        boolean existsDeepSession = Optional.ofNullable(userRecordListMap.get(ConversationType.DEEP_CONVERSATIONS.getCode()))
                .orElse(Collections.emptyList())
                .stream()
                .anyMatch(record -> toUserCode.equals(record.getToUserCode()));//是否存在深度会话

        if (userConversation == null) {
            return noUserConversationTree(firstSessionNumber, validSessionNumber, deepSessionNumber);
        } else {
            return existingUserConversationTree(existsFirstSession, existsValidSession, existsDeepSession,
                    firstSessionNumber, validSessionNumber, deepSessionNumber);
        }
    }

    public int evaluate(Map<Integer, List<UserConversationRecordDto>> userRecordListMap, int conversationsNumber) {
        return root.evaluate(userRecordListMap, conversationsNumber);
    }
}

